package com.imti.mall.order.controller;

import cn.hutool.core.collection.CollUtil;
import com.imti.mall.common.Api.CommonResult;
import com.imti.mall.common.Api.ResultCode;
import com.imti.mall.model.order.dto.AddCartItem;
import com.imti.mall.model.order.dto.Confirmation;
import com.imti.mall.model.order.dto.PayMoney;
import com.imti.mall.model.order.dto.SubmitOrder;
import com.imti.mall.model.order.pojo.OmsCartItem;
import com.imti.mall.model.order.pojo.OmsOrder;
import com.imti.mall.model.pms.pojo.PmsProduct;
import com.imti.mall.model.pms.pojo.PmsProductFullReduction;
import com.imti.mall.model.pms.pojo.PmsProductLadder;
import com.imti.mall.model.pms.pojo.PmsSkuStock;
import com.imti.mall.model.sms.pojo.SmsFlashPromotion;
import com.imti.mall.model.sms.pojo.SmsFlashPromotionProductRelation;
import com.imti.mall.model.sms.pojo.SmsFlashPromotionSession;
import com.imti.mall.model.user.pojo.UmsMember;
import com.imti.mall.model.user.pojo.UmsMemberReceiveAddress;
import com.imti.mall.order.service.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.*;

@RestController
@Api(tags = "购物车管理")
@RequestMapping("/api/v1/cartItem")
public class CartItemController {

    @Autowired
    CartItemService cartItemService;
    @Autowired
    ProductService productService;
    @Autowired
    SkuStockService skuStockService;
    @Autowired
    MemberService memberService;
    @Autowired
    MemberReceiveAddressService memberReceiveAddressService;
    @Autowired
    MemberPriceService memberPriceService;
    @Autowired
    OrderService orderService;
    @Autowired
    ProductLadderService productLadderService;
    @Autowired
    ProductFullReductionService productFullReductionService;
    @Autowired
    FlashPromotionProductRelationService flashPromotionProductRelationService;
    @Autowired
    FlashPromotionService flashPromotionService;
    @Autowired
    FlashPromotionSessionService flashPromotionSessionService;

    /**
     * 添加购物车
     * 商品id skuId 会员id
     * 根据商品表、sku表、会员表内的数据 添加
     * 如果购物车内有相同的商品 修改数量
     * 如果购物车内没有相同的商品 新增
     * 加的时候考虑限购问题 在活动期间且有限购的情况下
     * @param addCartItem 中存放的是  购物车中商品id productId,skuId productSkuId,用户id memberId,
     *            购买数量 quantity,添加到购物车的价格 price
     * @return
     */
    @ApiOperation(value = "添加购物车 addCartItem 中存放的是  购物车中商品id productId,skuId productSkuId,用户id memberId,\n" +
            "购买数量 quantity")
    @PostMapping("addCartItem")
    public CommonResult addCartItem(AddCartItem addCartItem){
        //根据用户id和sku id 来进行查询购物车的信息
        List<OmsCartItem> omsCartItemList= cartItemService.cartItemList(addCartItem.getMemberId(),addCartItem.getProductSkuId());
        //new一个 OmsCartItem实体类
        OmsCartItem omsCartItem=new OmsCartItem();
        //商品表   根据商品id查询 返回结果为对象
        PmsProduct pmsProduct=productService.getById(addCartItem.getProductId());
        int result=0;
        //如果购物车内没有相同的商品 则进行新增
        if(CollUtil.isEmpty(omsCartItemList)){
            if (pmsProduct.getPromotionStartTime()!=null  && pmsProduct.getPromotionEndTime()!=null) {
                //促销开始时间< 现在时间 <促销结束时间
                if (pmsProduct.getPromotionStartTime().before(new Date()) && pmsProduct.getPromotionEndTime().after(new Date())) {
                    if (pmsProduct.getPromotionPerLimit() < addCartItem.getQuantity()) {
                        //超出限购
                        return CommonResult.failed("超出限购数量");
                    }
                }
            }
            //商品SKU表 根据skuId查询 返回结果为对象
            PmsSkuStock pmsSkuStock=skuStockService.getById(addCartItem.getProductSkuId());
            //会员表 根据用户id查询 返回结果为对象
            UmsMember umsMember=memberService.getById(addCartItem.getMemberId());
            //购物车中商品id
            omsCartItem.setProductId(addCartItem.getProductId());
            //skuId
            omsCartItem.setProductSkuId(addCartItem.getProductSkuId());
            //用户id
            omsCartItem.setMemberId(addCartItem.getMemberId());
            //购买数量
            omsCartItem.setQuantity(addCartItem.getQuantity());
            //添加到购物车的价格 即为商品的原价 等结算时在考虑商品的优惠
            omsCartItem.setPrice(pmsProduct.getPrice());
            //商品主图
            omsCartItem.setProductPic(pmsProduct.getPic());
            //商品名称
            omsCartItem.setProductName(pmsProduct.getName());
            //商品副标题（卖点）
            omsCartItem.setProductSubTitle(pmsProduct.getSubTitle());
            //商品sku条码
            omsCartItem.setProductSkuCode(pmsSkuStock.getSkuCode());
            //会员昵称
            omsCartItem.setMemberNickname(umsMember.getNickname());
            //创建时间 sql 为now()
            //修改时间 新增无修改时间
            //是否删除 0:未删除; 1:已删除
            omsCartItem.setDeleteStatus(0);
            //商品分类id
            omsCartItem.setProductCategoryId(pmsProduct.getProductCategoryId());
            //商品品牌
            omsCartItem.setProductBrand(pmsProduct.getBrandName());
            //商品的条码(货号)
            omsCartItem.setProductSn(pmsProduct.getProductSn());
            //商品销售属性:[{'key':'颜色','value':'颜色'},{'key':'容量','value':'4G'}]
            omsCartItem.setProductAttr(pmsSkuStock.getSpData());
            //新增购物车信息
            result=cartItemService.addCartItem(omsCartItem);
        }else {
            //如果购物车有此商品信息
            if (pmsProduct.getPromotionStartTime()!=null && pmsProduct.getPromotionEndTime()!=null) {
                //促销开始时间< 现在时间 <促销结束时间
                if (pmsProduct.getPromotionStartTime().before(new Date()) && pmsProduct.getPromotionEndTime().after(new Date())) {
                    //如果限购数量<加入购物车数量+购物车已有数量
                    if (pmsProduct.getPromotionPerLimit() < addCartItem.getQuantity() + omsCartItemList.get(0).getQuantity()) {
                        //超出限购
                        return CommonResult.failed("购物车已有商品和加入购物车数量超出限购数量");
                    }
                }
            }
            //sql 写的是 quantity=quantity+#{quantity}   所以在此不做加减法处理
            omsCartItem.setQuantity(addCartItem.getQuantity());
            //skuId
            omsCartItem.setProductSkuId(addCartItem.getProductSkuId());
            //用户id
            omsCartItem.setMemberId(addCartItem.getMemberId());
            //修改时间 sql写 修改时间为now()
            //根据用户id和skuId来进行修改购物车表
            result=cartItemService.updateCartItem(omsCartItem);
        }
        if (result>0){
            return  CommonResult.success(ResultCode.SUCCESS.getCode(),"添加成功");
        }else {
            return  CommonResult.failed( "添加失败");
        }
    }

        /**
         * 确认单(用户选择购物车中商品 去结算)
         * @param confirmation 用户id memberId,商品id productId,商品skuId productSkuId
     * @return
     */
    @ApiOperation(value = "确认单(用户选择购物车中商品 去结算)  confirmation 用户id memberId,商品id productId,商品skuId productSkuId")
    @PostMapping("confirmation")
    public CommonResult confirmation(Confirmation confirmation){
        //用户的默认收货地址 有且仅有一条
        UmsMemberReceiveAddress umsMemberReceiveAddress=memberReceiveAddressService.memberReceiveAddress(confirmation.getMemberId());
        if (umsMemberReceiveAddress==null){
            return CommonResult.failed( "用户未设置默认收货地址");
        }
        //用户选择购买的商品 可能为一条商品也可能为多条商品
        //在购物车内选择要结算的
        List<OmsCartItem> omsCartItemList= new ArrayList<>();
        //订单总金额
        Double totalAmount=0.0;
        for (int i=0;i<confirmation.getProductSkuId().length;i++){
            omsCartItemList.add(cartItemService.cartItem(confirmation.getMemberId(),confirmation.getProductSkuId()[i]));
            totalAmount+=omsCartItemList.get(i).getPrice().doubleValue()*omsCartItemList.get(i).getQuantity();
        }
        //商品List
        List<PmsProduct> pmsProductList= new ArrayList<>();
        //可获得积分
        Double integration=0.0;
        //订单备注
        String note="";
        for (int i=0;i<confirmation.getProductId().length;i++){
            //根据用户结算的商品 根据商品id而不是skuId 来进行查询 因为促销时是根据商品来进行促销的(Spu)
            pmsProductList.add(productService.getById(confirmation.getProductId()[i]));
            integration+=pmsProductList.get(i).getGiftPoint()*cartItemService.quantity(confirmation.getMemberId(),confirmation.getProductId()[i]);
            note+=pmsProductList.get(i).getNote()+" ";
        }
        //优惠金额 第Key种优惠 Long表示是商品id Float表示是优惠金额
        Map<Long,Float> memberPriceMap=new HashMap<>();
        //每种(Sku)商品的新价格
        Map<Long, Float> newPriceMap=new HashMap<>();
        //待支付总金额
        Float payAmount=0F;
        //用户的个人信息
        UmsMember umsMember=memberService.getById(confirmation.getMemberId());
        int n=0;
        for (int i=0;i<confirmation.getProductSkuId().length;i++){
            //促销类型：0->没有促销使用原价;1->使用促销价；2->使用会员价；3->使用阶梯价格；4->使用满减价格；5->限时购
            if (pmsProductList.get(i).getPromotionType()==0){
                //如果不支持会员价则按原价支付
                newPriceMap.put(confirmation.getProductSkuId()[i],omsCartItemList.get(i).getPrice().floatValue());
                //payAmount+=omsCartItemList.get(i).getPrice().floatValue()*omsCartItemList.get(i).getQuantity();
            }else if(pmsProductList.get(i).getPromotionType()==1){
                //使用促销价
                Float memberPrice=pmsProductList.get(i).getPrice().floatValue()-pmsProductList.get(i).getPromotionPrice().floatValue();
                memberPriceMap.put(pmsProductList.get(i).getId(),memberPrice);
                //payAmount+=pmsProductList.get(i).getPromotionPrice().floatValue()*omsCartItemList.get(i).getQuantity();
            }else if(pmsProductList.get(i).getPromotionType()==2){
                //会员价
                //商品id
                Long productId=pmsProductList.get(i).getId();
                //对应的优惠金额
                Float memberPrice=memberPriceService.memberPrice(productId,umsMember.getMemberLevelId());
                memberPriceMap.put(productId,memberPrice);
            }else if(pmsProductList.get(i).getPromotionType()==3){
                //使用阶梯价格
                int count=0;
                PmsProductLadder productLadder=productLadderService.productLadderByproductId(pmsProductList.get(i).getId());
                for (int j=0;j<omsCartItemList.size();j++) {
                    //只要是购物车列表中的
                    if (pmsProductList.get(i).getId() == omsCartItemList.get(j).getProductId()) {
                        //对每一个sku商品的件数添加
                        count += omsCartItemList.get(j).getQuantity();
                    }
                }
                //如果达到了购买件数门槛则进行优惠计算
                if (count>=productLadder.getCount()){
                    //优惠的价格=原价-优惠后的价格
                    Float memberPrice=pmsProductList.get(i).getPrice().floatValue()-productLadder.getCount();
                    memberPriceMap.put(pmsProductList.get(i).getId(),memberPrice);
                }else {
                    memberPriceMap.put(pmsProductList.get(i).getId(),0f);
                }
            }else if(pmsProductList.get(i).getPromotionType()==4){
                //使用满减价格
                PmsProductFullReduction productFullReduction=productFullReductionService.productFullReduction(pmsProductList.get(i).getId());
                System.out.println(productFullReduction);
                BigDecimal allPrice=new BigDecimal(0);
                for (int j=0;j<omsCartItemList.size();j++){
                    if (pmsProductList.get(i).getId()==omsCartItemList.get(j).getProductId()){
                        //计算购买同一种商品的总金额
                        allPrice=allPrice.add(omsCartItemList.get(j).getPrice());
                    }
                }
                if (allPrice.compareTo(productFullReduction.getFullPrice())!=-1){
                    memberPriceMap.put(pmsProductList.get(i).getId(),productFullReduction.getReducePrice().floatValue());
                }else {
                    memberPriceMap.put(pmsProductList.get(i).getId(),0f);
                }
            }else if(pmsProductList.get(i).getPromotionType()==5){
                //限时购与商品关系表
                SmsFlashPromotionProductRelation flashPromotionProductRelation=flashPromotionProductRelationService.flashPromotionProductRelation(pmsProductList.get(i).getId());
                //限时购表(日期)
                SmsFlashPromotion flashPromotion=flashPromotionService.flashPromotion(flashPromotionProductRelation.getFlashPromotionId());
                //限时购场次表
                SmsFlashPromotionSession flashPromotionSession=flashPromotionSessionService.flashPromotionSession(flashPromotionProductRelation.getFlashPromotionSessionId());
                    //是否启用限时购
                    if (flashPromotionSession.getStatus()==1){
                        //限时购数量
                        if(flashPromotionProductRelation.getFlashPromotionCount()>0) {
                            //获取当前日期
                            LocalDate nowDate = LocalDate.now();
                            //开始日期
                            LocalDate beginDate = flashPromotion.getStartDate().toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
                            //结束日期
                            LocalDate endDate = flashPromotion.getEndDate().toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
                            //现在的日期要在限购活动的日期内
                            if (beginDate.isBefore(nowDate) && endDate.isAfter(nowDate)) {
                                //获取当前日的时间
                                LocalTime nowTime = LocalTime.now();
                                //开始时间
                                LocalTime beginTime = flashPromotionSession.getStartTime().toInstant().atZone(ZoneId.systemDefault()).toLocalTime();
                                //结束时间
                                LocalTime endTime = flashPromotionSession.getEndTime().toInstant().atZone(ZoneId.systemDefault()).toLocalTime();
                                //当前日的现在时间要在限购活动的场次内
                                if (beginTime.isBefore(nowTime) && endTime.isAfter(nowTime)) {
                                    //到这里才是属于限购活动的时间
                                    int countLimit = 0;
                                    for (int j = 0; j < omsCartItemList.size(); j++) {
                                        //同一种商品购买的数量
                                        if (omsCartItemList.get(j).getProductId() == pmsProductList.get(i).getId()) {
                                            countLimit += omsCartItemList.get(j).getQuantity();
                                        }
                                    }
                                    //如果超出限购数量 返回 商品名字 + 超出限购数量
                                    if (countLimit > flashPromotionProductRelation.getFlashPromotionLimit()) {
                                        return CommonResult.failed(pmsProductList.get(i).getName() + " 商品超出限购数量");
                                        //如果用户购买的数量大于限购数的库存 返回 商品名字 + 超出限购库存
                                    } else if (countLimit > flashPromotionProductRelation.getFlashPromotionCount()){
                                        return CommonResult.failed(pmsProductList.get(i).getName() + " 商品超出限购库存");
                                    }else {
                                            //如果是在活动时间内 并且购买数量小于限购数量
                                            memberPriceMap.put(pmsProductList.get(i).getId(), flashPromotionProductRelation.getFlashPromotionPrice().floatValue());
                                    }
                                } else {
                                    memberPriceMap.put(pmsProductList.get(i).getId(), 0f);
                                }
                            } else {
                                memberPriceMap.put(pmsProductList.get(i).getId(), 0f);
                            }
                        }else {
                            //如果商品被抢光了 应该关闭今天的限时购
                            flashPromotionSessionService.closeStatusByIdTrue(flashPromotionProductRelation.getFlashPromotionSessionId());
                            return CommonResult.failed(pmsProductList.get(i).getName()+" 商品已经被抢光了");
                        }
                    }else {
                        return CommonResult.failed("今日限时购已关闭");
                    }
                }
            //根据商品id和用户会员等级信息 查询会员等级价格表
            //一个商品返回值为一条或空(无会员优惠)
            if (newPriceMap.size()<omsCartItemList.size()){
                for (int j=0;j<confirmation.getProductSkuId().length;j++){
                    if (memberPriceMap.keySet().toArray()[i] == omsCartItemList.get(j).getProductId()) {
                        //优惠后的价格=(单件原价-优惠价格)*购买件数
                        Float newPrice=omsCartItemList.get(i).getPrice().floatValue()-memberPriceMap.get(memberPriceMap.keySet().toArray()[i]);
                        newPriceMap.put(confirmation.getProductSkuId()[i],newPrice);
                    }
                }
            }
            if (n< confirmation.getProductSkuId().length){
                for (int j=0;j< newPriceMap.size();j++){
                    if(newPriceMap.keySet().toArray()[i]==omsCartItemList.get(j).getProductSkuId()){
                    n++;
                    payAmount+=omsCartItemList.get(j).getQuantity()*newPriceMap.get(newPriceMap.keySet().toArray()[i]);
                    }
                }
            }
        }
        //优惠券 由于这个模块没人写 所以计算时不加优惠券
        //将所有的数据放到map内 返回给前台
        Map<String,Object> confirmationMap= new HashMap<>();
        //用户默认地址
        confirmationMap.put("umsMemberReceiveAddress",umsMemberReceiveAddress);
        //购物车中需要结算的商品
        confirmationMap.put("omsCartItemList",omsCartItemList);
        if (umsMember.getIntegration()!=0){
            //用户积分
            confirmationMap.put("useIntegration",umsMember.getIntegration());
            //积分可抵金额
            confirmationMap.put("integrationAmount",umsMember.getIntegration()/100);
        }else {
            //用户积分
            confirmationMap.put("useIntegration",0);
            //积分可抵金额
            confirmationMap.put("integrationAmount",0);
        }
        //原价
        confirmationMap.put("totalAmount",totalAmount);
        //商品合计多少元(优惠后)
        confirmationMap.put("payAmount",payAmount);
        //本单可获得积分
        confirmationMap.put("integration",integration);
        //优惠的价格
        confirmationMap.put("memberPriceMap",memberPriceMap);
        //根据key是sku  value是计算后的价格
        confirmationMap.put("newPriceMap",newPriceMap);
        //订单备注
        confirmationMap.put("note",note);
        //优惠
        confirmationMap.put("memberPriceMap",memberPriceMap);
        return  CommonResult.success(confirmationMap);
    }



    /**
     * 根据用户提交订单
     * 生成订单表(未支付状态)
     * @param submitOrder 从生成订单返回的信息
     * @return 订单编号 实付金额
     * @throws ParseException 日期转换异常
     */
    @ApiOperation(value = "根据用户提交订单,生成订单表(未支付状态)")
    @PostMapping("submitOrder")
    public CommonResult submitOrder(SubmitOrder submitOrder) throws ParseException {
        UmsMemberReceiveAddress umsMemberReceiveAddress=memberReceiveAddressService.memberReceiveAddressById(submitOrder.getAddressId());
        OmsOrder omsOrder=new OmsOrder();
        //用户id
        omsOrder.setMemberId(submitOrder.getMemberId());
        //订单编号:年月日时分加6位随机数
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date=new Date();
        String sn=(sdf.format(date).replace("-","").replace(":","").replace(" ","")+(Math.random()*9+1)*100000).substring(0,20);
        //omsOr时间
        omsOrder.setOrderSn(sn);
        //创建der.setCreateTime(new Date());
        //订单总金额(原价)
        omsOrder.setTotalAmount(BigDecimal.valueOf(submitOrder.getTotalAmount()));
        //实付金额(优惠后的金额)
        omsOrder.setPayAmount(submitOrder.getPayAmount());
        //运费
        omsOrder.setFreightAmount(BigDecimal.valueOf(0));
        //优惠的金额
        omsOrder.setPromotionAmount(omsOrder.getTotalAmount().subtract(omsOrder.getPayAmount()));
        //积分抵扣金额(这里需要前台判断 用户选择是否使用积分 如果使用了传值 如果用户不使用或无积分传0)
        if (submitOrder.getUseIntegration()>0){
            omsOrder.setIntegrationAmount(submitOrder.getIntegrationAmount());
            //如果使用了积分 更新用户的最新积分
            memberService.updateIntegrationById(submitOrder.getMemberId(),submitOrder.getUseIntegration());
        }
        //支付方式：0->未支付；1->支付宝；2->微信
        omsOrder.setPayType(0);
        //订单来源：0->PC订单；1->app订单
        omsOrder.setSourceType(1);
        //订单状态：0->待付款；1->待发货；2->已发货；3->已完成；4->已关闭；5->无效订单
        omsOrder.setStatus(0);
        //可获得积分
        omsOrder.setIntegration(submitOrder.getIntegration().intValue());
        //用户姓名
        UmsMember member=memberService.umsMember(submitOrder.getMemberId());
        omsOrder.setMemberUsername(member.getUsername());
        //收货人姓名
        omsOrder.setReceiverName(umsMemberReceiveAddress.getName());
        //收货人电话
        omsOrder.setReceiverPhone(umsMemberReceiveAddress.getPhoneNumber());
        //收货人邮编
        omsOrder.setReceiverPostCode(umsMemberReceiveAddress.getPostCode());
        //省份/直辖市
        omsOrder.setReceiverProvince(umsMemberReceiveAddress.getProvince());
        //城市
        omsOrder.setReceiverCity(umsMemberReceiveAddress.getCity());
        //区
        omsOrder.setReceiverRegion(umsMemberReceiveAddress.getRegion());
        //详细地址
        omsOrder.setReceiverDetailAddress(umsMemberReceiveAddress.getDetailAddress());
        //订单备注
        omsOrder.setNote(submitOrder.getNote());
        //删除状态：0->未删除；1->已删除
        omsOrder.setDeleteStatus(0);
        //下单时使用的积分
        omsOrder.setUseIntegration(submitOrder.getUseIntegration());
        //生成订单表
        int result=orderService.insertAll(omsOrder);
        //返回一个实付金额
        Map<String,Object> map=new HashMap<>();
        if (result>0){
            //订单编号
            map.put("orderSn",omsOrder.getOrderSn());
            //订单实付金额
            map.put("payAmount",omsOrder.getPayAmount());
            return  CommonResult.success(map);
        }else {
            return  CommonResult.failed("提交失败");
        }
    }

    /**
     * 点击支付按钮后 修改账单状态
     * @param payMoney 账单编号 支付方式 实付金额
     * @return 返回支付方式 实付金额
     */
    @ApiOperation(value = "点击支付按钮后 修改账单状态")
    @PostMapping("payMoney")
    public CommonResult payMoney(PayMoney payMoney){
        //根据账单编号和支付方式修改账单状态
        int result=orderService.updateOrderPay(payMoney.getOrderSn(),payMoney.getPayType());
        for (int i=0;i<payMoney.getCartItemId().length;i++){
            result+=cartItemService.updateDeleteStatus(payMoney.getCartItemId()[i]);
        }
        Map<String,Object> map=new HashMap<>();
        if (result>1){
            //支付方式：0->未支付；1->支付宝；2->微信
            if (payMoney.getPayType()==1){
                map.put("payType","支付宝支付");
            }else if (payMoney.getPayType()==2){
                map.put("payType","微信支付");
            }
            map.put("payAmount",payMoney.getPayAmount());
            return CommonResult.success(map);
        }else {
            return CommonResult.failed("支付失败");
        }
    }

    /**
     * 用户的全部收货地址
     * @param memberId 用户id
     * @return
     */
    @ApiOperation(value = "用户的全部收货地址")
    @GetMapping("memberReceiveAddressList/{memberId}")
    public CommonResult  memberReceiveAddressList(@PathVariable Long memberId){
        List<UmsMemberReceiveAddress> memberReceiveAddressList=memberReceiveAddressService.memberReceiveAddressList(memberId);
        //hutool工具类操作集合 判断集合是否不等于空
        if (CollUtil.isNotEmpty(memberReceiveAddressList)){
            return  CommonResult.success(memberReceiveAddressList);
        }else {
            return  CommonResult.failed( "用户还未添加收货地址");
        }
    }


    /**
     * 根据用户id查询用户购物车信息
     * @param memberId 用户id
     * @return
     */
    @ApiOperation(value ="根据用户id查询用户购物车信息")
    @GetMapping("cartItem/{memberId}")
    public CommonResult cartItem(@PathVariable Long memberId){
        List<OmsCartItem> omsCartItemList=cartItemService.cartItemList(memberId,null);
        if (CollUtil.isNotEmpty(omsCartItemList)){
            return CommonResult.success(omsCartItemList);
        }else {
            return CommonResult.failed("用户购物车信息为空");
        }
    }

}
